<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="previous" href="Global.html">
<link rel="next" href="OptParse.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of class methods" rel=Appendix href="index_methods.html">
<link title="Index of classes" rel=Appendix href="index_classes.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Base64" rel="Chapter" href="Base64.html">
<link title="BitSet" rel="Chapter" href="BitSet.html">
<link title="Dllist" rel="Chapter" href="Dllist.html">
<link title="DynArray" rel="Chapter" href="DynArray.html">
<link title="Enum" rel="Chapter" href="Enum.html">
<link title="ExtArray" rel="Chapter" href="ExtArray.html">
<link title="ExtHashtbl" rel="Chapter" href="ExtHashtbl.html">
<link title="ExtLib" rel="Chapter" href="ExtLib.html">
<link title="ExtList" rel="Chapter" href="ExtList.html">
<link title="ExtString" rel="Chapter" href="ExtString.html">
<link title="Global" rel="Chapter" href="Global.html">
<link title="IO" rel="Chapter" href="IO.html">
<link title="OptParse" rel="Chapter" href="OptParse.html">
<link title="Option" rel="Chapter" href="Option.html">
<link title="PMap" rel="Chapter" href="PMap.html">
<link title="RefList" rel="Chapter" href="RefList.html">
<link title="Std" rel="Chapter" href="Std.html">
<link title="UChar" rel="Chapter" href="UChar.html">
<link title="UTF8" rel="Chapter" href="UTF8.html">
<link title="Unzip" rel="Chapter" href="Unzip.html"><link title="Standard API" rel="Section" href="#6_StandardAPI">
<link title="Creation of IO Inputs/Outputs" rel="Section" href="#6_CreationofIOInputsOutputs">
<link title="Utilities" rel="Section" href="#6_Utilities">
<link title="Binary files API" rel="Section" href="#6_BinaryfilesAPI">
<link title="Bits API" rel="Section" href="#6_BitsAPI">
<link title="Generic IO Object Wrappers" rel="Section" href="#6_GenericIOObjectWrappers">
<title>IO</title>
</head>
<body>
<div class="navbar"><a class="pre" href="Global.html" title="Global">Previous</a>
&nbsp;<a class="up" href="index.html" title="Index">Up</a>
&nbsp;<a class="post" href="OptParse.html" title="OptParse">Next</a>
</div>
<h1>Module <a href="type_IO.html">IO</a></h1>
<pre><span class="keyword">module</span> IO: <code class="code">sig</code> <a href="IO.html">..</a> <code class="code">end</code></pre><div class="info">
High-order abstract I/O.
<p>

	IO module simply deals with abstract inputs/outputs. It provides a
	set of methods for working with these IO as well as several
	constructors that enable to write to an underlying channel, buffer,
	or enum.<br>
</div>
<hr width="100%">
<pre><span id="TYPEinput"><span class="keyword">type</span> <code class="type"></code>input</span> </pre>
<div class="info">
The abstract input type.<br>
</div>

<pre><span id="TYPEoutput"><span class="keyword">type</span> <code class="type">'a</code> output</span> </pre>
<div class="info">
The abstract output type, <code class="code">'a</code> is the accumulator data, it is returned
	when the <code class="code">close_out</code> function is called.<br>
</div>

<pre><span id="EXCEPTIONNo_more_input"><span class="keyword">exception</span> No_more_input</span></pre>
<div class="info">
This exception is raised when reading on an input with the <code class="code">read</code> or
  <code class="code">nread</code> functions while there is no available token to read.<br>
</div>
<pre><span id="EXCEPTIONInput_closed"><span class="keyword">exception</span> Input_closed</span></pre>
<div class="info">
This exception is raised when reading on a closed input.<br>
</div>
<pre><span id="EXCEPTIONOutput_closed"><span class="keyword">exception</span> Output_closed</span></pre>
<div class="info">
This exception is raised when reading on a closed output.<br>
</div>
<br>
<h6 id="6_StandardAPI">Standard API</h6><br>
<pre><span id="VALread"><span class="keyword">val</span> read</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> char</code></pre><div class="info">
Read a single char from an input or raise <code class="code">No_more_input</code> if
  no input available.<br>
</div>
<pre><span id="VALnread"><span class="keyword">val</span> nread</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> string</code></pre><div class="info">
<code class="code">nread i n</code> reads a string of size up to <code class="code">n</code> from an input.
  The function will raise <code class="code">No_more_input</code> if no input is available.
  It will raise <code class="code">Invalid_argument</code> if <code class="code">n</code> &lt; 0.<br>
</div>
<pre><span id="VALreally_nread"><span class="keyword">val</span> really_nread</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int -> string</code></pre><div class="info">
<code class="code">really_nread i n</code> reads a string of exactly <code class="code">n</code> characters
  from the input. Raises <code class="code">No_more_input</code> if at least <code class="code">n</code> characters are
  not available. Raises <code class="code">Invalid_argument</code> if <code class="code">n</code> &lt; 0.<br>
</div>
<pre><span id="VALinput"><span class="keyword">val</span> input</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string -> int -> int -> int</code></pre><div class="info">
<code class="code">input i s p l</code> reads up to <code class="code">l</code> characters from the given input, storing
  them in string <code class="code">s</code>, starting at character number <code class="code">p</code>. It returns the actual
  number of characters read or raise <code class="code">No_more_input</code> if no character can be
  read. It will raise <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a
  valid substring of <code class="code">s</code>.<br>
</div>
<pre><span id="VALreally_input"><span class="keyword">val</span> really_input</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string -> int -> int -> int</code></pre><div class="info">
<code class="code">really_input i s p l</code> reads exactly <code class="code">l</code> characters from the given input,
  storing them in the string <code class="code">s</code>, starting at position <code class="code">p</code>. For consistency with
  <a href="IO.html#VALinput"><code class="code">IO.input</code></a> it returns <code class="code">l</code>. Raises <code class="code">No_more_input</code> if at <code class="code">l</code> characters are
  not available. Raises <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a
  valid substring of <code class="code">s</code>.<br>
</div>
<pre><span id="VALclose_in"><span class="keyword">val</span> close_in</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> unit</code></pre><div class="info">
Close the input. It can no longer be read from.<br>
</div>
<pre><span id="VALwrite"><span class="keyword">val</span> write</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> char -> unit</code></pre><div class="info">
Write a single char to an output.<br>
</div>
<pre><span id="VALnwrite"><span class="keyword">val</span> nwrite</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info">
Write a string to an output.<br>
</div>
<pre><span id="VALoutput"><span class="keyword">val</span> output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> int -> int -> int</code></pre><div class="info">
<code class="code">output o s p l</code> writes up to <code class="code">l</code> characters from string <code class="code">s</code>, starting at
  offset <code class="code">p</code>. It returns the number of characters written. It will raise
  <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not designate a valid substring of <code class="code">s</code>.<br>
</div>
<pre><span id="VALreally_output"><span class="keyword">val</span> really_output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> int -> int -> int</code></pre><div class="info">
<code class="code">really_output o s p l</code> writes exactly <code class="code">l</code> characters from string <code class="code">s</code> onto
  the the output, starting with the character at offset <code class="code">p</code>. For consistency with
  <a href="IO.html#VALoutput"><code class="code">IO.output</code></a> it returns <code class="code">l</code>. Raises <code class="code">Invalid_argument</code> if <code class="code">p</code> and <code class="code">l</code> do not
  designate a valid substring of <code class="code">s</code>.<br>
</div>
<pre><span id="VALflush"><span class="keyword">val</span> flush</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> unit</code></pre><div class="info">
Flush an output.<br>
</div>
<pre><span id="VALclose_out"><span class="keyword">val</span> close_out</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> 'a</code></pre><div class="info">
Close the output and return its accumulator data.
  It can no longer be written.<br>
</div>
<br>
<h6 id="6_CreationofIOInputsOutputs">Creation of IO Inputs/Outputs</h6><br>
<pre><span id="VALinput_string"><span class="keyword">val</span> input_string</span> : <code class="type">string -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info">
Create an input that will read from a string.<br>
</div>
<pre><span id="VALoutput_string"><span class="keyword">val</span> output_string</span> : <code class="type">unit -> string <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Create an output that will write into a string in an efficient way.
  When closed, the output returns all the data written into it.<br>
</div>
<pre><span id="VALoutput_strings"><span class="keyword">val</span> output_strings</span> : <code class="type">unit -> string list <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Create an output that will write into a string in an efficient way.
  When closed, the output returns all the data written into it. 
  Several strings are used in case the output size excess max_string_length<br>
</div>
<pre><span id="VALinput_channel"><span class="keyword">val</span> input_channel</span> : <code class="type">Pervasives.in_channel -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info">
Create an input that will read from a channel.<br>
</div>
<pre><span id="VALoutput_channel"><span class="keyword">val</span> output_channel</span> : <code class="type">Pervasives.out_channel -> unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Create an output that will write into a channel.<br>
</div>
<pre><span id="VALinput_enum"><span class="keyword">val</span> input_enum</span> : <code class="type">char <a href="Enum.html#TYPEt">Enum.t</a> -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info">
Create an input that will read from an <code class="code">enum</code>.<br>
</div>
<pre><span id="VALoutput_enum"><span class="keyword">val</span> output_enum</span> : <code class="type">unit -> char <a href="Enum.html#TYPEt">Enum.t</a> <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Create an output that will write into an <code class="code">enum</code>. The 
  final enum is returned when the output is closed.<br>
</div>
<pre><span id="VALcreate_in"><span class="keyword">val</span> create_in</span> : <code class="type">read:(unit -> char) -><br>       input:(string -> int -> int -> int) -> close:(unit -> unit) -> <a href="IO.html#TYPEinput">input</a></code></pre><div class="info">
Fully create an input by giving all the needed functions.<br>
</div>
<pre><span id="VALcreate_out"><span class="keyword">val</span> create_out</span> : <code class="type">write:(char -> unit) -><br>       output:(string -> int -> int -> int) -><br>       flush:(unit -> unit) -> close:(unit -> 'a) -> 'a <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Fully create an output by giving all the needed functions.<br>
</div>
<br>
<h6 id="6_Utilities">Utilities</h6><br>
<pre><span id="VALscanf"><span class="keyword">val</span> scanf</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> ('a, 'b, 'c, 'd) Scanf.scanner</code></pre><div class="info">
The scanf function works for any input.<br>
</div>
<pre><span id="VALprintf"><span class="keyword">val</span> printf</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> ('b, unit, string, unit) Pervasives.format4 -> 'b</code></pre><div class="info">
The printf function works for any output.<br>
</div>
<pre><span id="VALread_all"><span class="keyword">val</span> read_all</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info">
read all the contents of the input until <code class="code">No_more_input</code> is raised.<br>
</div>
<pre><span id="VALpipe"><span class="keyword">val</span> pipe</span> : <code class="type">unit -> <a href="IO.html#TYPEinput">input</a> * unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
Create a pipe between an input and an ouput. Data written from
  the output can be read from the input.<br>
</div>
<pre><span id="VALpos_in"><span class="keyword">val</span> pos_in</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> <a href="IO.html#TYPEinput">input</a> * (unit -> int)</code></pre><div class="info">
Create an input that provide a count function of the number of bytes
  read from it.<br>
</div>
<pre><span id="VALpos_out"><span class="keyword">val</span> pos_out</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> 'a <a href="IO.html#TYPEoutput">output</a> * (unit -> int)</code></pre><div class="info">
Create an output that provide a count function of the number of bytes
  written through it.<br>
</div>
<pre><span id="VALcast_output"><span class="keyword">val</span> cast_output</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre><div class="info">
You can safely transform any output to an unit output in a safe way 
  by using this function.<br>
</div>
<br>
<h6 id="6_BinaryfilesAPI">Binary files API</h6>
<p>

	Here is some API useful for working with binary files, in particular
	binary files generated by C applications. By default, encoding of
	multibyte integers is low-endian. The BigEndian module provide multibyte
	operations with other encoding.<br>
<pre><span id="EXCEPTIONOverflow"><span class="keyword">exception</span> Overflow</span> <span class="keyword">of</span> <code class="type">string</code></pre>
<div class="info">
Exception raised when a read or write operation cannot be completed.<br>
</div>
<pre><span id="VALread_byte"><span class="keyword">val</span> read_byte</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info">
Read an unsigned 8-bit integer.<br>
</div>
<pre><span id="VALread_signed_byte"><span class="keyword">val</span> read_signed_byte</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info">
Read an signed 8-bit integer.<br>
</div>
<pre><span id="VALread_ui16"><span class="keyword">val</span> read_ui16</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info">
Read an unsigned 16-bit word.<br>
</div>
<pre><span id="VALread_i16"><span class="keyword">val</span> read_i16</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info">
Read a signed 16-bit word.<br>
</div>
<pre><span id="VALread_i32"><span class="keyword">val</span> read_i32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int</code></pre><div class="info">
Read a signed 32-bit integer. Raise <code class="code">Overflow</code> if the
  read integer cannot be represented as a Caml 31-bit integer.<br>
</div>
<pre><span id="VALread_real_i32"><span class="keyword">val</span> read_real_i32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int32</code></pre><div class="info">
Read a signed 32-bit integer as an OCaml int32.<br>
</div>
<pre><span id="VALread_i64"><span class="keyword">val</span> read_i64</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> int64</code></pre><div class="info">
Read a signed 64-bit integer as an OCaml int64.<br>
</div>
<pre><span id="VALread_float32"><span class="keyword">val</span> read_float32</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> float</code></pre><div class="info">
Read an IEEE single precision floating point value (32 bits).<br>
</div>
<pre><span id="VALread_double"><span class="keyword">val</span> read_double</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> float</code></pre><div class="info">
Read an IEEE double precision floating point value (64 bits).<br>
</div>
<pre><span id="VALread_string"><span class="keyword">val</span> read_string</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info">
Read a null-terminated string.<br>
</div>
<pre><span id="VALread_line"><span class="keyword">val</span> read_line</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> string</code></pre><div class="info">
Read a LF or CRLF terminated string.<br>
</div>
<pre><span id="VALwrite_byte"><span class="keyword">val</span> write_byte</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info">
Write an unsigned 8-bit byte.<br>
</div>
<pre><span id="VALwrite_ui16"><span class="keyword">val</span> write_ui16</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info">
Write an unsigned 16-bit word.<br>
</div>
<pre><span id="VALwrite_i16"><span class="keyword">val</span> write_i16</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info">
Write a signed 16-bit word.<br>
</div>
<pre><span id="VALwrite_i32"><span class="keyword">val</span> write_i32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int -> unit</code></pre><div class="info">
Write a signed 32-bit integer.<br>
</div>
<pre><span id="VALwrite_real_i32"><span class="keyword">val</span> write_real_i32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int32 -> unit</code></pre><div class="info">
Write an OCaml int32.<br>
</div>
<pre><span id="VALwrite_i64"><span class="keyword">val</span> write_i64</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> int64 -> unit</code></pre><div class="info">
Write an OCaml int64.<br>
</div>
<pre><span id="VALwrite_float32"><span class="keyword">val</span> write_float32</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> float -> unit</code></pre><div class="info">
Write an IEEE single precision floating point value (32 bits).<br>
</div>
<pre><span id="VALwrite_double"><span class="keyword">val</span> write_double</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> float -> unit</code></pre><div class="info">
Write an IEEE double precision floating point value (64 bits).<br>
</div>
<pre><span id="VALwrite_string"><span class="keyword">val</span> write_string</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info">
Write a string and append an null character.<br>
</div>
<pre><span id="VALwrite_line"><span class="keyword">val</span> write_line</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> string -> unit</code></pre><div class="info">
Write a line and append a LF (it might be converted
	to CRLF on some systems depending on the underlying IO).<br>
</div>
<pre><span class="keyword">module</span> <a href="IO.BigEndian.html">BigEndian</a>: <code class="code">sig</code> <a href="IO.BigEndian.html">..</a> <code class="code">end</code></pre><div class="info">
Same as operations above, but use big-endian encoding
</div>
<br>
<h6 id="6_BitsAPI">Bits API</h6>
<p>

	This enable you to read and write from an IO bit-by-bit or several bits
	at the same time.<br>
<pre><span id="TYPEin_bits"><span class="keyword">type</span> <code class="type"></code>in_bits</span> </pre>

<pre><span id="TYPEout_bits"><span class="keyword">type</span> <code class="type"></code>out_bits</span> </pre>

<pre><span id="EXCEPTIONBits_error"><span class="keyword">exception</span> Bits_error</span></pre>
<pre><span id="VALinput_bits"><span class="keyword">val</span> input_bits</span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> <a href="IO.html#TYPEin_bits">in_bits</a></code></pre><div class="info">
Read bits from an input<br>
</div>
<pre><span id="VALoutput_bits"><span class="keyword">val</span> output_bits</span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> <a href="IO.html#TYPEout_bits">out_bits</a></code></pre><div class="info">
Write bits to an output<br>
</div>
<pre><span id="VALread_bits"><span class="keyword">val</span> read_bits</span> : <code class="type"><a href="IO.html#TYPEin_bits">in_bits</a> -> int -> int</code></pre><div class="info">
Read up to 31 bits, raise Bits_error if n &lt; 0 or n &gt; 31<br>
</div>
<pre><span id="VALwrite_bits"><span class="keyword">val</span> write_bits</span> : <code class="type"><a href="IO.html#TYPEout_bits">out_bits</a> -> nbits:int -> int -> unit</code></pre><div class="info">
Write up to 31 bits represented as a value, raise Bits_error if nbits &lt; 0
 or nbits &gt; 31 or the value representation excess nbits.<br>
</div>
<pre><span id="VALflush_bits"><span class="keyword">val</span> flush_bits</span> : <code class="type"><a href="IO.html#TYPEout_bits">out_bits</a> -> unit</code></pre><div class="info">
Flush remaining unwritten bits, adding up to 7 bits which values 0.<br>
</div>
<pre><span id="VALdrop_bits"><span class="keyword">val</span> drop_bits</span> : <code class="type"><a href="IO.html#TYPEin_bits">in_bits</a> -> unit</code></pre><div class="info">
Drop up to 7 buffered bits and restart to next input character.<br>
</div>
<br>
<h6 id="6_GenericIOObjectWrappers">Generic IO Object Wrappers</h6>
<p>

	Theses OO Wrappers have been written to provide easy support of ExtLib
	IO by external librairies. If you want your library to support ExtLib
	IO without actually requiring ExtLib to compile, you can should implement
	the classes <code class="code">in_channel</code>, <code class="code">out_channel</code>, <code class="code">poly_in_channel</code> and/or
	<code class="code">poly_out_channel</code> which are the common IO specifications established
	for ExtLib, OCamlNet and Camomile.
<p>

	(see http://www.ocaml-programming.de/tmp/IO-Classes.html for more details).<br>
<pre><span name="TYPEin_channel"><span class="keyword">class</span> <a href="IO.in_channel-c.html">in_channel</a></span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> </code><code class="code">object</code> <a href="IO.in_channel-c.html">..</a> <code class="code">end</code></pre><pre><span name="TYPEout_channel"><span class="keyword">class</span> <a href="IO.out_channel-c.html">out_channel</a></span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> </code><code class="code">object</code> <a href="IO.out_channel-c.html">..</a> <code class="code">end</code></pre><pre><span name="TYPEin_chars"><span class="keyword">class</span> <a href="IO.in_chars-c.html">in_chars</a></span> : <code class="type"><a href="IO.html#TYPEinput">input</a> -> </code><code class="code">object</code> <a href="IO.in_chars-c.html">..</a> <code class="code">end</code></pre><pre><span name="TYPEout_chars"><span class="keyword">class</span> <a href="IO.out_chars-c.html">out_chars</a></span> : <code class="type">'a <a href="IO.html#TYPEoutput">output</a> -> </code><code class="code">object</code> <a href="IO.out_chars-c.html">..</a> <code class="code">end</code></pre><pre><span id="VALfrom_in_channel"><span class="keyword">val</span> from_in_channel</span> : <code class="type">#<a href="IO.in_channel-c.html">in_channel</a> -> <a href="IO.html#TYPEinput">input</a></code></pre><pre><span id="VALfrom_out_channel"><span class="keyword">val</span> from_out_channel</span> : <code class="type">#<a href="IO.out_channel-c.html">out_channel</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre><pre><span id="VALfrom_in_chars"><span class="keyword">val</span> from_in_chars</span> : <code class="type">#<a href="IO.in_chars-c.html">in_chars</a> -> <a href="IO.html#TYPEinput">input</a></code></pre><pre><span id="VALfrom_out_chars"><span class="keyword">val</span> from_out_chars</span> : <code class="type">#<a href="IO.out_chars-c.html">out_chars</a> -> unit <a href="IO.html#TYPEoutput">output</a></code></pre></body></html>